   This is an introduction to `Programming in Emacs Lisp', for people
who are not programmers.

   Edition 1.05, 21 October 1997

   Copyright (C) 1990, '91, '92, '93, '94, '95, '97 Free Software
Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "Copying" and "GNU General Public License"
are included exactly as in the original, and provided that the entire
resulting derived work is distributed under the terms of a permission
notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by the Free Software Foundation.

   This master menu first lists each chapter and index; then it lists
every node in every chapter.

Preface
*******

   Most of the GNU Emacs text editor is written in the programming
language called Emacs Lisp.  The code written in this programming
language is the software--the sets of instructions--that tell the
computer what to do when you give it commands.  Emacs is designed so
that you can write new code in Emacs Lisp and easily install it as an
extension to the editor.  This is why Emacs is called the "extensible
editor".

   (Indeed, since Emacs does so much more than provide editing
capabilities, it should perhaps be called an "extensible computing
environment", but that phrase is quite a mouthful.  Also, everything
you do in Emacs--find the Mayan date and phases of the moon, simplify
polynomials, debug code, manage files, read letters, write books--all
these activities are kinds of editing in the most general sense of the
word.)

   Although Emacs Lisp is usually thought of in association with the
text editor, it is a full computer programming language.  You can use
it as you would any other programming language.

   Perhaps you want to understand programming; perhaps you want to
extend Emacs; or perhaps you want to become a programmer.  This
introduction to Emacs Lisp is designed to get you started: to guide you
in learning the fundamentals of programming, and more importantly, to
show you how you can teach yourself to go further.

On Reading this Text
====================

   All through this document, you will see little sample programs you
can run inside of Emacs.  If you read this document in Info inside of
GNU Emacs, you can run the programs as they appear.  (This is easy to
do and is explained when the examples are presented.)  Alternatively,
you can read this introduction as a printed book while sitting beside a
computer running Emacs.  (This is what I like to do; I like printed
books.)  If you don't have a running Emacs beside you, you can still
read this book, but in this case, it is best to treat it as a novel or
as a travel guide to a country not yet visited: interesting, but not
the same as being there.

   Much of this introduction is dedicated to walk-throughs or guided
tours of code used in GNU Emacs.  These tours are designed for two
purposes: first, to give you familiarity with real, working code (code
you use every day); and, second, to give you familiarity with the way
Emacs works.  It is interesting to see how an editor is implemented.
Also, I hope that you will pick up the habit of browsing through source
code.  You can learn from it and mine it for ideas.  Having GNU Emacs
is like having a dragon's cave of treasures.

   In addition to learning about Emacs as an editor and Emacs Lisp as a
programming language, the examples and guided tours will give you an
opportunity to get acquainted with Emacs as a Lisp programming
environment.  GNU Emacs supports programming and provides tools that
you will want to become comfortable using, such as `M-.' (the key which
invokes the `find-tag' command).  You will also learn about buffers and
other objects that are part of the editing environment.  Learning about
these features of Emacs is like learning new routes around your home
town.

   Finally, I hope to convey some of the skills for using Emacs to
learn aspects of programming that you don't know.  You can often use
Emacs to help you understand what puzzles you or to find out how to do
something new.  This self-reliance is not only a pleasure, but an
advantage.

For Whom This is Written
========================

   This text is written as an elementary introduction for people who are
not programmers.  If you are a programmer, you may not be satisfied with
this primer.  The reason is that you may have become expert at reading
reference manuals and be put off by the way this text is organized.

   An expert programmer who reviewed this text said to me:

     I prefer to learn from reference manuals.  I "dive into" each
     paragraph, and "come up for air" between paragraphs.

     When I get to the end of a paragraph, I assume that that subject is
     done, finished, that I know everything I need (with the possible
     exception of the case when the next paragraph starts talking about
     it in more detail).  I expect that a well written reference manual
     will not have a lot of redundancy, and that it will have excellent
     pointers to the (one) place where the information I want is.

   This introduction is not written for this person!

   Firstly, I try to say everything at least three times: first, to
introduce it; second, to show it in context; and third, to show it in a
different context, or to review it.

   Secondly, I hardly ever put all the information about a subject in
one place, much less in one paragraph.  To my way of thinking, that
imposes too heavy a burden on the reader.  Instead I try to explain
only what you need to know at the time.  (Sometimes I include a little
extra information so you won't be surprised later when the additional
information is formally introduced.)

   When you read this text, you are not expected to learn everything the
first time.  Frequently, you need only make, as it were, a `nodding
acquaintance' with some of the items mentioned.  My hope is that I have
structured the text and given you enough hints that you will be alert to
what is important, and concentrate on it.

   You will need to "dive into" some paragraphs; there is no other way
to read them.  But I have tried to keep down the number of such
paragraphs.  This book is intended as an approachable hill, rather than
as a daunting mountain.

   This *introduction* to `Programming in Emacs Lisp' has a companion
document, see The GNU Emacs Lisp Reference Manual (elisp).  The
reference manual has more detail than this introduction.  In the
reference manual, all the information about one topic is concentrated
in one place.  You should turn to it if you are like the programmer
quoted above.  And, of course, after you have read this `Introduction',
you will find the `Reference Manual' useful when you are writing your
own programs.

Lisp History
============

   Lisp was first developed in the late 1950s at the Massachusetts
Institute of Technology for research in artificial intelligence.  The
great power of the Lisp language makes it superior for other purposes as
well, such as writing editor commands.

   GNU Emacs Lisp is largely inspired by Maclisp, which was written at
MIT in the 1960's.  It is somewhat inspired by Common Lisp, which
became a standard in the 1980s.  However, Emacs Lisp is much simpler
than Common Lisp.  (The standard Emacs distribution contains an
optional extensions file, `cl.el', that adds many Common Lisp features
to Emacs Lisp.)

A Note for Novices
==================

   If you don't know GNU Emacs, you can still read this document
profitably.  However, I recommend you learn Emacs, if only to learn to
move around your computer screen.  You can teach yourself how to use
Emacs with the on-line tutorial.  To use it, type `C-h t'.  (This means
you press and release the <CTRL> key and the `h' at the same time, and
then press and release `t'.)

   Also, I often refer to one of Emacs's standard commands by listing
the keys which you press to invoke the command and then giving the name
of the command in parentheses, like this: `M-C-\' (`indent-region').
What this means is that the `indent-region' command is customarily
invoked by typing `M-C-\'.  (You can, if you wish, change the keys that
are typed to invoke the command; this is called "rebinding".  See
Keymaps.)  The abbreviation `M-C-\' means that you type your
<META> key, <CTRL> key and <\> key all at the same time.  Sometimes a
combination like this is called a keychord, since it is similar to the
way you play a chord on a piano.  If your keyboard does not have a
<META> key, the <ESC> key prefix is used in place of it.  In this case,
`M-C-\' means that you press and release your <ESC> key and then type
the <CTRL> key and the <\> key at the same time.

   If you are reading this in Info using GNU Emacs, you can read through
this whole document just by pressing the space bar, <SPC>.  (To learn
about Info, type `C-h i' and then select Info.)

   A note on terminology:  when I use the word Lisp alone, I am usually
referring to the various dialects of Lisp in general, but when I speak
of Emacs Lisp, I am referring to GNU Emacs Lisp in particular.

Thank You
=========

   My thanks to all who helped me with this book.  My especial thanks to
Jim Blandy, Noah Friedman, Jim Kingdon, Roland McGrath, Frank Ritter,
Randy Smith, Richard M. Stallman, and Melissa Weisshaus.  My thanks
also go to both Philip Johnson and David Stampe for their patient
encouragement.  My mistakes are my own.

List Processing
***************

   To the untutored eye, Lisp is a strange programming language.  In
Lisp code there are parentheses everywhere.  Some people even claim
that the name stands for `Lots of Isolated Silly Parentheses'.  But the
claim is unwarranted.  Lisp stands for LISt Processing and the
programming language handles *lists* (and lists of lists) by putting
them between parentheses.  The parentheses mark the boundaries of the
list.  Sometimes a list is preceded by a single apostrophe or quotation
mark, `''.  Lists are the basis of Lisp.

Lisp Lists
==========

   In Lisp, a list looks like this: `'(rose violet daisy buttercup)'.
This list is preceded by a single apostrophe.  It could just as well be
written as follows, which looks more like the kind of list you are
likely to be familiar with:

     '(rose
       violet
       daisy
       buttercup)

The elements of this list are the names of the four different flowers,
separated from each other by whitespace and surrounded by parentheses,
like flowers in a field with a stone wall around them.

   Lists can also have numbers in them, as in this list: `(+ 2 2)'.
This list has a plus-sign, `+', followed by two `2's, each separated by
whitespace.

   In Lisp, both data and programs are represented the same way; that
is, they are both lists of words, numbers, or other lists, separated by
whitespace and surrounded by parentheses.  (Since a program looks like
data, one program may easily serve as data for another; this is a very
powerful feature of Lisp.)  (Incidentally, these two parenthetical
remarks are *not* Lisp lists, because they contain `;' and `.' as
punctuation marks.)

   Here is another list, this time with a list inside of it:

     '(this list has (a list inside of it))

   The components of this list are the words `this', `list', `has', and
the list `(a list inside of it)'.  The interior list is made up of the
words `a', `list', `inside', `of', `it'.

Lisp Atoms
----------

   In Lisp, what we have been calling words are called "atoms".  This
term comes from the historical meaning of the word atom, which means
`indivisible'.  As far as Lisp is concerned, the words we have been
using in the lists cannot be divided into any smaller parts and still
mean the same thing as part of a program; likewise with numbers and
single character symbols like `+'.  On the other hand, unlike an atom,
a list can be split into parts.  (see `car' `cdr' & `cons' Fundamental Functions.)

   In a list, atoms are separated from each other by whitespace.  They
can be right next to a parenthesis.

   Technically speaking, a list in Lisp consists of parentheses
surrounding atoms separated by whitespace or surrounding other lists or
surrounding both atoms and other lists.  A list can have just one atom
in it or have nothing in it at all.  A list with nothing in it looks
like this: `()', and is called the "empty list".  Unlike anything else,
an empty list is considered both an atom and a list at the same time.

   The printed representation of both atoms and lists are called
"symbolic expressions" or, more concisely, "s-expressions".  The word
"expression" by itself can refer to either the printed representation,
or to the atom or list as it is held internally in the computer.
Often, people use the term "expression" indiscriminately.  (Also, in
many texts, the word "form" is used as a synonym for expression.)

   Incidentally, the atoms that make up our universe were named such
when they were thought to be indivisible; but it has been found that
physical atoms are not indivisible.  Parts can split off an atom or it
can fission into two parts of roughly equal size.  Physical atoms were
named prematurely, before their truer nature was found.  In Lisp,
certain kinds of atom, such as an array, can be separated into parts;
but the mechanism for doing this is different from the mechanism for
splitting a list.  As far as list operations are concerned, the atoms
of a list are unsplittable.

   As in English, the meanings of the component letters of a Lisp atom
are different from the meaning the letters make as a word.  For
example, the word for the South American sloth, the `ai', is completely
different from the two words, `a', and `i'.

   There are many kinds of atom in nature but only a few in Lisp: for
example, "numbers", such as 37, 511, or 1729, and "symbols", such as
`+', `foo', or `forward-line'.  The words we have listed in the
examples above are all symbols.  In everyday Lisp conversation, the
word "atom" is not often used, because programmers usually try to be
more specific about what kind of atom they are dealing with.  Lisp
programming is mostly about symbols (and sometimes numbers) within
lists.  (Incidentally, the preceding three word parenthetical remark is
a proper list in Lisp, since it consists of atoms, which in this case
are symbols, separated by whitespace and enclosed by parentheses,
without any non-Lisp punctuation.)

   In addition, text between double quotation marks--even sentences or
paragraphs--is an atom.  Here is an example:

     '(this list includes "text between quotation marks.")

In Lisp, all of the quoted text including the punctuation mark and the
blank spaces is a single atom.  This kind of atom is called a "string"
(for `string of characters') and is the sort of thing that is used for
messages that a computer can print for a human to read.  Strings are a
different kind of atom than numbers or symbols and are used differently.

Whitespace in Lists
-------------------

   The amount of whitespace in a list does not matter.  From the point
of view of the Lisp language,

     '(this list
        looks like this)

is exactly the same as this:

     '(this list looks like this)

   Both examples show what to Lisp is the same list, the list made up of
the symbols `this', `list', `looks', `like', and `this' in that order.

   Extra whitespace and newlines are designed to make a list more
readable by humans.  When Lisp reads the expression, it gets rid of all
the extra whitespace (but it needs to have at least one space between
atoms in order to tell them apart.)

   Odd as it seems, the examples we have seen cover almost all of what
Lisp lists look like!  Every other list in Lisp looks more or less like
one of these examples, except that the list may be longer and more
complex.  In brief, a list is between parentheses, a string is between
quotation marks, a symbol looks like a word, and a number looks like a
number.  (For certain situations, square brackets, dots and a few other
special characters may be used; however, we will go quite far without
them.)

GNU Emacs Helps You Type Lists
------------------------------

   If you type a Lisp expression in GNU Emacs using either Lisp
Interaction mode or Emacs Lisp mode, you will have available to you
several commands to format the Lisp expression so it is easy to read.
For example, pressing the <TAB> key automatically indents the line the
cursor is on by the right amount.  A command to properly indent the
code in a region is customarily bound to `M-C-\'.  Indentation is
designed so that you can see which elements of a list belongs to which
list--elements of a sub-list are indented more than the elements of the
enclosing list.

   In addition, when you type a closing parenthesis, Emacs momentarily
jumps the cursor back to the matching opening parenthesis, so you can
see which one it is.  This is very useful, since every list you type in
Lisp must have its closing parenthesis match its opening parenthesis.
(see Major Modes (emacs), for more information about
Emacs' modes.)

Run a Program
=============

   A list in Lisp--any list--is a program ready to run.  If you run it
(for which the Lisp jargon is "evaluate"), the computer will do one of
three things: do nothing except return to you the list itself; send you
an error message; or, treat the first symbol in the list as a command
to do something.  (Usually, of course, it is the last of these three
things that you really want!)

   The single apostrophe, `'', that I put in front of some of the
example lists in preceding sections is called a "quote"; when it
precedes a list, it tells Lisp to do nothing with the list, other than
take it as it is written.  But if there is no quote preceding a list,
the first item of the list is special: it is a command for the computer
to obey.  (In Lisp, these commands are called *functions*.)  The list
`(+ 2 2)' shown above did not have a quote in front of it, so Lisp
understands that the `+' is an instruction to do something with the
rest of the list; in this case, to add the numbers that follow.

   If you are reading this inside of GNU Emacs in Info, here is how you
can evaluate such a list:  place your cursor immediately after the right
hand parenthesis of the following list and then type `C-x C-e':

     (+ 2 2)

You will see the number `4' appear in the echo area.  (In the jargon,
what you have just done is "evaluate the list."  The echo area is the
line at the bottom of the screen that displays or "echoes" text.)  Now
try the same thing with a quoted list:  place the cursor right after
the following list and type `C-x C-e':

     '(this is a quoted list)

In this case, you will see `(this is a quoted list)' appear in the echo
area.

   In both cases, what you are doing is giving a command to the program
inside of GNU Emacs called the "Lisp interpreter"--giving the
interpreter a command to evaluate the expression.  The name of the Lisp
interpreter comes from the word for the task done by a human who comes
up with the meaning of an expression--who "interprets" it.

   You can also evaluate an atom that is not part of a list--one that is
not surrounded by parentheses; again, the Lisp interpreter translates
from the humanly readable expression to the language of the computer.
But before discussing this (see Variables.), we will discuss what
the Lisp interpreter does when you make an error.

Generate an Error Message
=========================

   Partly so you won't worry if you do it accidentally, we will now give
a command to the Lisp interpreter that generates an error message.
This is a harmless activity; and indeed, we will often try to generate
error messages intentionally.  Once you understand the jargon, error
messages can be informative.  Instead of being called "error" messages,
they should be called "help" messages.  They are like signposts to a
traveller in a strange country; decyphering them can be hard, but once
understood, they can point the way.

   What we will do is evaluate a list that is not quoted and does not
have a meaningful command as its first element.  Here is a list almost
exactly the same as the one we just used, but without the single-quote
in front of it.  Position the cursor right after it and type `C-x C-e':

     (this is an unquoted list)

This time, you will see the following appear in the echo area:

     Symbol's function definition is void: this

(Also, your terminal may beep at you--some do, some don't; and others
blink.  This is just a device to get your attention.)  The message goes
away as soon as you type another key, even just to move the cursor.

   Based on what we already know, we can almost read this error message.
We know the meaning of the word `Symbol'.  In this case, it refers to
the first atom of the list, the word `this'.  The word `function' was
mentioned once before.  It is a very important word.  For our purposes,
we can define it by saying that a "function" is a set of instructions
to the computer that tell the computer to do something.  (Technically,
the symbol tells the computer where to find the instructions, but this
is a complication we can ignore for the moment.)

   Now we can begin to understand the error message: `Symbol's function
definition is void: this'.  The symbol (that is, the word `this') does
not have a definition of any set of instructions for the computer to
carry out.

   The slightly odd wording of the message, `function definition is
void', is designed to cover the way Emacs Lisp is implemented, which is
that when the symbol does not have a function definition attached to it,
the place that should contain the instructions is `void'.

   On the other hand, since we were able to add 2 plus 2 successfully,
by evaluating `(+ 2 2)', we can infer that the symbol `+' must have a
set of instructions for the computer to obey and those instructions
must be to add the numbers that follow the `+'.

Symbol Names and Function Definitions
=====================================

   We can articulate another characteristic of Lisp based on what we
have discussed so far--an important characteristic: a symbol, like `+',
is not itself the set of instructions for the computer to carry out.
Instead, the symbol is used, perhaps temporarily, as a way of locating
the definition or set of instructions.  What we see is the name through
which the instructions can be found.  Names of people work the same
way.  I can be referred to as `Bob'; however, I am not the letters `B',
`o', `b' but am the consciousness consistently associated with a
particular life-form.  The name is not me, but it can be used to refer
to me.

   In Lisp, one set of instructions can be attached to several names.
For example, the computer instructions for adding numbers can be linked
to the symbol `plus' as well as to the symbol `+' (and are in some
dialects of Lisp).  Among humans, I can be referred to as `Robert' as
well as `Bob' and by other words as well.

   On the other hand, a symbol can have only one function definition
attached to it at a time.  Otherwise, the computer would be confused as
to which definition to use.  If this were the case among people, only
one person in the world could be named `Bob'.  However, the function
definition to which the name refers can be changed readily.  (see
Install a Function Definition.)

   Since Emacs Lisp is large, it is customary to name symbols in a way
that identifies the part of Emacs to which the function belongs.  Thus,
all the names for functions that deal with Texinfo start with
`texinfo-' and those for functions that deal with reading mail start
with `rmail-'.

The Lisp Interpreter
====================

   Based on what we have seen, we can now start to figure out what the
Lisp interpreter does when we command it to evaluate a list.  First, it
looks to see whether there is a quote before the list; if there is, the
interpreter just gives us the list.  On the other hand, if there is no
quote, the interpreter looks at the first element in the list and sees
whether it has a function definition.  If it does, the interpreter
carries out the instructions in the function definition.  Otherwise,
the interpreter prints an error message.

   This is how Lisp works.  Simple.  There are added complications
which we will get to in a minute, but these are the fundamentals.  Of
course, to write Lisp programs, you need to know how to write function
definitions and attach them to names, and how to do this without
confusing either yourself or the computer.

   Now, for the first complication.  In addition to lists, the Lisp
interpreter can evaluate a symbol that is not quoted and does not have
parentheses around it.  In this case, the Lisp interpreter will attempt
to determine the symbol's value as a "variable".  This situation is
described in the section on variables.  (see Variables.)

   The second complication occurs because some functions are unusual
and do not work in the usual manner.  Those that don't are called
"special forms".  They are used for special jobs, like defining a
function, and there are not many of them.  In the next few chapters,
you will be introduced to several of the more important special forms.

   The third and final complication is this: if the function that the
Lisp interpreter is looking at is not a special form, and if it is part
of a list, the Lisp interpreter looks to see whether the list has a list
inside of it.  If there is an inner list, the Lisp interpreter first
figures out what it should do with the inside list, and then it works on
the outside list.  If there is yet another list embedded inside the
inner list, it works on that one first, and so on.  It always works on
the innermost list first.  The interpreter works on the innermost list
first in order to find out the result of doing that.  The result may be
used by the enclosing expression.

   Otherwise, the interpreter works left to right, from one expression
to the next.

Byte Compiling
--------------

   One other aspect of interpreting: the Lisp interpreter is able to
interpret two kinds of entity: humanly readable code, on which we will
focus exclusively, and specially processed code, called "byte compiled"
code, which is not humanly readable.  Byte compiled code runs faster
than humanly readable code.

   You can transform humanly readable code into byte compiled code by
running one of the compile commands such as `byte-compile-file'.  Byte
compiled code is usually stored in a file that ends with a `.elc'
extension rather than a `.el' extension.  You will see both kinds of
file in the `emacs/lisp' directory; the files to read are those with
`.el' extensions.

   As a practical matter, for most things you might do to customize or
extend Emacs, you do not need to byte compile; and I will not discuss
the topic here.  See Byte Compilation (elisp), for a
full description of byte compilation.

Evaluation
==========

   When the Lisp interpreter works on an expression, the term for the
activity is called "evaluation".  We say that the interpreter
`evaluates the expression'.  I've used this term several times before.
The word comes from its use in everyday language, `to ascertain the
value or amount of; to appraise', according to `Webster's New
Collegiate Dictionary'.

   After evaluating an expression, the Lisp interpreter will most likely
"return" the value that the computer produces by carrying out the
instructions it found in the function definition, or perhaps it will
give up on that function and produce an error message.  (The interpreter
may also find itself tossed, so to speak, to a different function or it
may attempt to repeat continually what it is doing for ever and ever in
what is called an `infinite loop'.  These actions are less common; and
we can ignore them.)  Most frequently, the interpreter returns a value.

   At the same time the interpreter returns a value, it may do something
else as well, such as move a cursor or copy a file; this other kind of
action is called a "side effect".  Actions that we humans think are
important, such as printing results, are often "side effects" to the
Lisp interpreter.  The jargon can sound peculiar, but it turns out that
it is fairly easy to learn to use side effects.

   In summary, evaluating a symbolic expression most commonly causes the
Lisp interpreter to return a value and perhaps carry out a side effect;
or else produce an error.